<!DOCTYPE html>
<html lang="zh-cn" itemscope itemtype="http://schema.org/WebPage">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title> - 友知弄</title>
  

<meta name="renderer" content="webkit" />
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"/>

<meta name="MobileOptimized" content="width"/>
<meta name="HandheldFriendly" content="true"/>


<meta name="applicable-device" content="pc,mobile">

<meta name="theme-color" content="#f8f5ec" />
<meta name="msapplication-navbutton-color" content="#f8f5ec">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="#f8f5ec">

<meta name="mobile-web-app-capable" content="yes">

<meta name="author" content="yixy" />
  <meta name="description" content="OS笔记(8)——内存页面置换算法 发生缺页中断时，OS必须在内存中选择一个页面将其换出内存，以便为即将调入的页面腾出空间。如果要换出的页面在内存驻留期间已经被修改过，就必须把它写回磁盘以更新该页面在磁盘上的副本；如果该页面没有被修改过，那么它的磁盘上的副本不需要被回写，直接使用调入的页面覆盖原有页面就行了。
最好的两种算法是老化算法和工作集时钟算法，它们分别基于LRU和工作集，具有良好的页面调度性能，可以有效的实现。
1. 最优页面算法 该算法是可以给出的最好的页面算法，遗憾的是该算法不可能实现。
 最优页面算法：假设每个页面都可以用在该页面首次被访问前要执行的指令数作为标记，该算法规定应置换标记最大的页面。  2. 最近未使用页面置换算法（Not Recently Used） 当启动一个进程时，操作系统为其每个页面设置两个状态位R和W（其初始值为0）：页面被访问时设置R位为1，页面被修改时设置W位为1。
注意，R位定期（比如时钟中断）会被清0，以区别最近没有被访问的页面和被访问的页面。
页面根据其R和W值可被分为四类：
1 2 3 4  第0类：R=0，M=0 第1类：R=0，M=1 第2类：R=1，M=0 第4类：R=1，M=1    NRU算法：随机地从类编号最小的非空类中挑选一个页面淘汰之。  NRU算法可以看做是LRU算法的一个粗糙的实现。
3. 先进先出算法（First In First Out） 操作系统维护一个队列（通常是链表），存放内存中的页面，每次淘汰队首的页面，将最新进入的页面放到队尾。
因为可能抛弃重要页面，所以该算法一般不会单独使用。
4. 第二次机会页面置换算法（second chance） 第二次机会页面置换算法是FIFO算法的升级版。
 第二次机会算法：对FIFO进行了简单的修改，在淘汰页面时，会判断该页R位是否被设置，若R位没被设置则淘汰该页面，否则将该页面R位清0，并且将其放入队尾，然后重新在队首进行搜索。  5. 时钟页面置换算法（clock） clock算法是对FIFO和第二次机会算法的一个优化，使用环形链表实现数据结构，避免在链表中移动页面，减少不必要的开销。
6. 最近最少使用页面置换算法（Least Recently Used） 对最优页面置换算法的一个很好的近似是基于这样的观察：在前面几条指令中频繁使用的页面很可能在后面的几条指令中被使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内仍然不会被使用。
 LRU算法：在缺页中断发生时，置换掉未使用时间最长的页面。  虽然LRU在理论上是可以实现的，但代价很高。为了完全实现LRU，需要在内存中维护一个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾。困难的是在每次访问内存时都必须要更新整个链表。在链表中找到一个页面，删除它，然后把它移动到表头是一个非常费时的操作，即使使用硬件实现也一样费时（假设有这样的硬件）。
 然而，还是有一些使用特殊硬件实现LRU的方法。首先考虑一个最简单的近似方法，这个方法要求硬件有一个64位计数器C，它在每条指令执行完后自动加1，每个页表项必须有一个足够容纳这个计数器值的域。在每次访问内存后，将当前的C值保存到被访问页面的页表项中。一旦发生缺页中断，操作系统就检查所有页表项中计数器的值，找到值最小的一个页面，这个页面就是最近最少使用的页面。（这看起来实际上是一个硬件版本的NUR算法）
现在让我们看一看第二个硬件实现的LRU算法。在一个有n个页框的机器中，LRU硬件可以维持一个初值为0的n×n位的矩阵。当访问到页框k时，硬件首先把k行的位都设置成1，再把k列的位都设置成0。在任何时刻，二进制数值最小的行就是最近最少使用的，第二小的行是下一个最近最少使用的，以此类推。
 前面两种LRU算法虽然在理论上都是可以实现的，但只有非常少的计算机拥有这种硬件。因此，需要一个能用软件实现的解决方案。
7. 使用软件模拟LRU：NUR 和 老化算法 只有非常少的计算机支持硬件实现LRU。因此，需要考虑一个能够使用软件实现的解决方案。
 NFU（Not Frequently Used，最不常用）算法：该算法将每个页面与一个软件计数器相关联，计数器的初值为0。每次时钟中断时，由操作系统扫描内存中所有的页面，将每个页面的R位（它的值是0或1）加到它的计数器上。这个计数器大体上跟踪了各个页面被访问的频繁程度。发生缺页中断时，则置换计数器值最小的页面。NFU的主要问题是它“从来不忘记任何事情”。 老化算法：老化算法对NFU进行了修正。首先，在R位被加进之前先将计数器右移一位；其次，将R位加到计数器最左端的位而不是最右端的位。发生缺页中断时，将置换计数器值最小的页面。  8." />

  <meta name="keywords" content="essay, notes" />






<meta name="generator" content="Hugo 0.56.1" />


<link rel="canonical" href="https://yixy.github.io/youzhilane/post/01%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/os%E7%AC%94%E8%AE%B08%E5%86%85%E5%AD%98%E9%A1%B5%E9%9D%A2%E7%BD%AE%E6%8D%A2%E7%AE%97%E6%B3%95/" />



<link rel="icon" href="/youzhilane/favicon.ico" />











<link rel="stylesheet" href="/youzhilane/sass/jane.min.af20b78e95c84de86b00a0242a4a77bd2601700e1b250edf27537d957ac0041d.css" integrity="sha256-ryC3jpXITehrAKAkKkp3vSYBcA4bJQ7fJ1N9lXrABB0=" media="screen" crossorigin="anonymous">





<meta property="og:title" content="" />
<meta property="og:description" content="OS笔记(8)——内存页面置换算法 发生缺页中断时，OS必须在内存中选择一个页面将其换出内存，以便为即将调入的页面腾出空间。如果要换出的页面在内存驻留期间已经被修改过，就必须把它写回磁盘以更新该页面在磁盘上的副本；如果该页面没有被修改过，那么它的磁盘上的副本不需要被回写，直接使用调入的页面覆盖原有页面就行了。
最好的两种算法是老化算法和工作集时钟算法，它们分别基于LRU和工作集，具有良好的页面调度性能，可以有效的实现。
1. 最优页面算法 该算法是可以给出的最好的页面算法，遗憾的是该算法不可能实现。
 最优页面算法：假设每个页面都可以用在该页面首次被访问前要执行的指令数作为标记，该算法规定应置换标记最大的页面。  2. 最近未使用页面置换算法（Not Recently Used） 当启动一个进程时，操作系统为其每个页面设置两个状态位R和W（其初始值为0）：页面被访问时设置R位为1，页面被修改时设置W位为1。
注意，R位定期（比如时钟中断）会被清0，以区别最近没有被访问的页面和被访问的页面。
页面根据其R和W值可被分为四类：
1 2 3 4  第0类：R=0，M=0 第1类：R=0，M=1 第2类：R=1，M=0 第4类：R=1，M=1    NRU算法：随机地从类编号最小的非空类中挑选一个页面淘汰之。  NRU算法可以看做是LRU算法的一个粗糙的实现。
3. 先进先出算法（First In First Out） 操作系统维护一个队列（通常是链表），存放内存中的页面，每次淘汰队首的页面，将最新进入的页面放到队尾。
因为可能抛弃重要页面，所以该算法一般不会单独使用。
4. 第二次机会页面置换算法（second chance） 第二次机会页面置换算法是FIFO算法的升级版。
 第二次机会算法：对FIFO进行了简单的修改，在淘汰页面时，会判断该页R位是否被设置，若R位没被设置则淘汰该页面，否则将该页面R位清0，并且将其放入队尾，然后重新在队首进行搜索。  5. 时钟页面置换算法（clock） clock算法是对FIFO和第二次机会算法的一个优化，使用环形链表实现数据结构，避免在链表中移动页面，减少不必要的开销。
6. 最近最少使用页面置换算法（Least Recently Used） 对最优页面置换算法的一个很好的近似是基于这样的观察：在前面几条指令中频繁使用的页面很可能在后面的几条指令中被使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内仍然不会被使用。
 LRU算法：在缺页中断发生时，置换掉未使用时间最长的页面。  虽然LRU在理论上是可以实现的，但代价很高。为了完全实现LRU，需要在内存中维护一个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾。困难的是在每次访问内存时都必须要更新整个链表。在链表中找到一个页面，删除它，然后把它移动到表头是一个非常费时的操作，即使使用硬件实现也一样费时（假设有这样的硬件）。
 然而，还是有一些使用特殊硬件实现LRU的方法。首先考虑一个最简单的近似方法，这个方法要求硬件有一个64位计数器C，它在每条指令执行完后自动加1，每个页表项必须有一个足够容纳这个计数器值的域。在每次访问内存后，将当前的C值保存到被访问页面的页表项中。一旦发生缺页中断，操作系统就检查所有页表项中计数器的值，找到值最小的一个页面，这个页面就是最近最少使用的页面。（这看起来实际上是一个硬件版本的NUR算法）
现在让我们看一看第二个硬件实现的LRU算法。在一个有n个页框的机器中，LRU硬件可以维持一个初值为0的n×n位的矩阵。当访问到页框k时，硬件首先把k行的位都设置成1，再把k列的位都设置成0。在任何时刻，二进制数值最小的行就是最近最少使用的，第二小的行是下一个最近最少使用的，以此类推。
 前面两种LRU算法虽然在理论上都是可以实现的，但只有非常少的计算机拥有这种硬件。因此，需要一个能用软件实现的解决方案。
7. 使用软件模拟LRU：NUR 和 老化算法 只有非常少的计算机支持硬件实现LRU。因此，需要考虑一个能够使用软件实现的解决方案。
 NFU（Not Frequently Used，最不常用）算法：该算法将每个页面与一个软件计数器相关联，计数器的初值为0。每次时钟中断时，由操作系统扫描内存中所有的页面，将每个页面的R位（它的值是0或1）加到它的计数器上。这个计数器大体上跟踪了各个页面被访问的频繁程度。发生缺页中断时，则置换计数器值最小的页面。NFU的主要问题是它“从来不忘记任何事情”。 老化算法：老化算法对NFU进行了修正。首先，在R位被加进之前先将计数器右移一位；其次，将R位加到计数器最左端的位而不是最右端的位。发生缺页中断时，将置换计数器值最小的页面。  8." />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://yixy.github.io/youzhilane/post/01%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/os%E7%AC%94%E8%AE%B08%E5%86%85%E5%AD%98%E9%A1%B5%E9%9D%A2%E7%BD%AE%E6%8D%A2%E7%AE%97%E6%B3%95/" />

<meta itemprop="name" content="">
<meta itemprop="description" content="OS笔记(8)——内存页面置换算法 发生缺页中断时，OS必须在内存中选择一个页面将其换出内存，以便为即将调入的页面腾出空间。如果要换出的页面在内存驻留期间已经被修改过，就必须把它写回磁盘以更新该页面在磁盘上的副本；如果该页面没有被修改过，那么它的磁盘上的副本不需要被回写，直接使用调入的页面覆盖原有页面就行了。
最好的两种算法是老化算法和工作集时钟算法，它们分别基于LRU和工作集，具有良好的页面调度性能，可以有效的实现。
1. 最优页面算法 该算法是可以给出的最好的页面算法，遗憾的是该算法不可能实现。
 最优页面算法：假设每个页面都可以用在该页面首次被访问前要执行的指令数作为标记，该算法规定应置换标记最大的页面。  2. 最近未使用页面置换算法（Not Recently Used） 当启动一个进程时，操作系统为其每个页面设置两个状态位R和W（其初始值为0）：页面被访问时设置R位为1，页面被修改时设置W位为1。
注意，R位定期（比如时钟中断）会被清0，以区别最近没有被访问的页面和被访问的页面。
页面根据其R和W值可被分为四类：
1 2 3 4  第0类：R=0，M=0 第1类：R=0，M=1 第2类：R=1，M=0 第4类：R=1，M=1    NRU算法：随机地从类编号最小的非空类中挑选一个页面淘汰之。  NRU算法可以看做是LRU算法的一个粗糙的实现。
3. 先进先出算法（First In First Out） 操作系统维护一个队列（通常是链表），存放内存中的页面，每次淘汰队首的页面，将最新进入的页面放到队尾。
因为可能抛弃重要页面，所以该算法一般不会单独使用。
4. 第二次机会页面置换算法（second chance） 第二次机会页面置换算法是FIFO算法的升级版。
 第二次机会算法：对FIFO进行了简单的修改，在淘汰页面时，会判断该页R位是否被设置，若R位没被设置则淘汰该页面，否则将该页面R位清0，并且将其放入队尾，然后重新在队首进行搜索。  5. 时钟页面置换算法（clock） clock算法是对FIFO和第二次机会算法的一个优化，使用环形链表实现数据结构，避免在链表中移动页面，减少不必要的开销。
6. 最近最少使用页面置换算法（Least Recently Used） 对最优页面置换算法的一个很好的近似是基于这样的观察：在前面几条指令中频繁使用的页面很可能在后面的几条指令中被使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内仍然不会被使用。
 LRU算法：在缺页中断发生时，置换掉未使用时间最长的页面。  虽然LRU在理论上是可以实现的，但代价很高。为了完全实现LRU，需要在内存中维护一个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾。困难的是在每次访问内存时都必须要更新整个链表。在链表中找到一个页面，删除它，然后把它移动到表头是一个非常费时的操作，即使使用硬件实现也一样费时（假设有这样的硬件）。
 然而，还是有一些使用特殊硬件实现LRU的方法。首先考虑一个最简单的近似方法，这个方法要求硬件有一个64位计数器C，它在每条指令执行完后自动加1，每个页表项必须有一个足够容纳这个计数器值的域。在每次访问内存后，将当前的C值保存到被访问页面的页表项中。一旦发生缺页中断，操作系统就检查所有页表项中计数器的值，找到值最小的一个页面，这个页面就是最近最少使用的页面。（这看起来实际上是一个硬件版本的NUR算法）
现在让我们看一看第二个硬件实现的LRU算法。在一个有n个页框的机器中，LRU硬件可以维持一个初值为0的n×n位的矩阵。当访问到页框k时，硬件首先把k行的位都设置成1，再把k列的位都设置成0。在任何时刻，二进制数值最小的行就是最近最少使用的，第二小的行是下一个最近最少使用的，以此类推。
 前面两种LRU算法虽然在理论上都是可以实现的，但只有非常少的计算机拥有这种硬件。因此，需要一个能用软件实现的解决方案。
7. 使用软件模拟LRU：NUR 和 老化算法 只有非常少的计算机支持硬件实现LRU。因此，需要考虑一个能够使用软件实现的解决方案。
 NFU（Not Frequently Used，最不常用）算法：该算法将每个页面与一个软件计数器相关联，计数器的初值为0。每次时钟中断时，由操作系统扫描内存中所有的页面，将每个页面的R位（它的值是0或1）加到它的计数器上。这个计数器大体上跟踪了各个页面被访问的频繁程度。发生缺页中断时，则置换计数器值最小的页面。NFU的主要问题是它“从来不忘记任何事情”。 老化算法：老化算法对NFU进行了修正。首先，在R位被加进之前先将计数器右移一位；其次，将R位加到计数器最左端的位而不是最右端的位。发生缺页中断时，将置换计数器值最小的页面。  8.">



<meta itemprop="wordCount" content="67">



<meta itemprop="keywords" content="" />
<meta name="twitter:card" content="summary"/>
<meta name="twitter:title" content=""/>
<meta name="twitter:description" content="OS笔记(8)——内存页面置换算法 发生缺页中断时，OS必须在内存中选择一个页面将其换出内存，以便为即将调入的页面腾出空间。如果要换出的页面在内存驻留期间已经被修改过，就必须把它写回磁盘以更新该页面在磁盘上的副本；如果该页面没有被修改过，那么它的磁盘上的副本不需要被回写，直接使用调入的页面覆盖原有页面就行了。
最好的两种算法是老化算法和工作集时钟算法，它们分别基于LRU和工作集，具有良好的页面调度性能，可以有效的实现。
1. 最优页面算法 该算法是可以给出的最好的页面算法，遗憾的是该算法不可能实现。
 最优页面算法：假设每个页面都可以用在该页面首次被访问前要执行的指令数作为标记，该算法规定应置换标记最大的页面。  2. 最近未使用页面置换算法（Not Recently Used） 当启动一个进程时，操作系统为其每个页面设置两个状态位R和W（其初始值为0）：页面被访问时设置R位为1，页面被修改时设置W位为1。
注意，R位定期（比如时钟中断）会被清0，以区别最近没有被访问的页面和被访问的页面。
页面根据其R和W值可被分为四类：
1 2 3 4  第0类：R=0，M=0 第1类：R=0，M=1 第2类：R=1，M=0 第4类：R=1，M=1    NRU算法：随机地从类编号最小的非空类中挑选一个页面淘汰之。  NRU算法可以看做是LRU算法的一个粗糙的实现。
3. 先进先出算法（First In First Out） 操作系统维护一个队列（通常是链表），存放内存中的页面，每次淘汰队首的页面，将最新进入的页面放到队尾。
因为可能抛弃重要页面，所以该算法一般不会单独使用。
4. 第二次机会页面置换算法（second chance） 第二次机会页面置换算法是FIFO算法的升级版。
 第二次机会算法：对FIFO进行了简单的修改，在淘汰页面时，会判断该页R位是否被设置，若R位没被设置则淘汰该页面，否则将该页面R位清0，并且将其放入队尾，然后重新在队首进行搜索。  5. 时钟页面置换算法（clock） clock算法是对FIFO和第二次机会算法的一个优化，使用环形链表实现数据结构，避免在链表中移动页面，减少不必要的开销。
6. 最近最少使用页面置换算法（Least Recently Used） 对最优页面置换算法的一个很好的近似是基于这样的观察：在前面几条指令中频繁使用的页面很可能在后面的几条指令中被使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内仍然不会被使用。
 LRU算法：在缺页中断发生时，置换掉未使用时间最长的页面。  虽然LRU在理论上是可以实现的，但代价很高。为了完全实现LRU，需要在内存中维护一个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾。困难的是在每次访问内存时都必须要更新整个链表。在链表中找到一个页面，删除它，然后把它移动到表头是一个非常费时的操作，即使使用硬件实现也一样费时（假设有这样的硬件）。
 然而，还是有一些使用特殊硬件实现LRU的方法。首先考虑一个最简单的近似方法，这个方法要求硬件有一个64位计数器C，它在每条指令执行完后自动加1，每个页表项必须有一个足够容纳这个计数器值的域。在每次访问内存后，将当前的C值保存到被访问页面的页表项中。一旦发生缺页中断，操作系统就检查所有页表项中计数器的值，找到值最小的一个页面，这个页面就是最近最少使用的页面。（这看起来实际上是一个硬件版本的NUR算法）
现在让我们看一看第二个硬件实现的LRU算法。在一个有n个页框的机器中，LRU硬件可以维持一个初值为0的n×n位的矩阵。当访问到页框k时，硬件首先把k行的位都设置成1，再把k列的位都设置成0。在任何时刻，二进制数值最小的行就是最近最少使用的，第二小的行是下一个最近最少使用的，以此类推。
 前面两种LRU算法虽然在理论上都是可以实现的，但只有非常少的计算机拥有这种硬件。因此，需要一个能用软件实现的解决方案。
7. 使用软件模拟LRU：NUR 和 老化算法 只有非常少的计算机支持硬件实现LRU。因此，需要考虑一个能够使用软件实现的解决方案。
 NFU（Not Frequently Used，最不常用）算法：该算法将每个页面与一个软件计数器相关联，计数器的初值为0。每次时钟中断时，由操作系统扫描内存中所有的页面，将每个页面的R位（它的值是0或1）加到它的计数器上。这个计数器大体上跟踪了各个页面被访问的频繁程度。发生缺页中断时，则置换计数器值最小的页面。NFU的主要问题是它“从来不忘记任何事情”。 老化算法：老化算法对NFU进行了修正。首先，在R位被加进之前先将计数器右移一位；其次，将R位加到计数器最左端的位而不是最右端的位。发生缺页中断时，将置换计数器值最小的页面。  8."/>

<!--[if lte IE 9]>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/classlist/1.1.20170427/classList.min.js"></script>
<![endif]-->

<!--[if lt IE 9]>
  <script src="https://cdn.jsdelivr.net/npm/html5shiv@3.7.3/dist/html5shiv.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/respond.js@1.4.2/dest/respond.min.js"></script>
<![endif]-->




</head>
<body>
  <div id="mobile-navbar" class="mobile-navbar">
  <div class="mobile-header-logo">
    <a href="/youzhilane/" class="logo">友知弄</a>
  </div>
  <div class="mobile-navbar-icon">
    <span></span>
    <span></span>
    <span></span>
  </div>
</div>
<nav id="mobile-menu" class="mobile-menu slideout-menu">
  <ul class="mobile-menu-list">
    <li class="mobile-menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/">主页</a>
          
        
      </li><li class="mobile-menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/categories/">分类</a>
          
        
      </li><li class="mobile-menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/booklist/">书单</a>
          
        
      </li><li class="mobile-menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/about/">关于友知弄</a>
          
        
      </li><li class="mobile-menu-item">
        
          
          
            <a class="menu-item-link" href="https://github.com/yixy" rel="noopener" target="_blank">
              GitHub
              
              <i class="iconfont">
                <svg class="icon" viewBox="0 0 1024 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="18" height="18">
  <path d="M623.36 272.96 473.216 423.04C467.2 429.056 467.072 438.656 472.896 444.416c0 0-6.72-6.656 1.6 1.6C496.064 467.648 528.64 500.224 528.64 500.224 534.464 506.048 544 505.856 550.016 499.904l150.08-150.144 67.328 66.432c9.024 8.96 27.456 4.544 30.4-8.96 19.968-92.608 46.656-227.52 46.656-227.52 6.848-34.496-16.192-56.704-49.92-49.92 0 0-134.656 26.816-227.328 46.784C560.32 178.048 556.352 182.272 554.752 187.136c-3.2 6.208-3.008 14.208 3.776 20.992L623.36 272.96z"></path>
  <path d="M841.152 457.152c-30.528 0-54.784 24.512-54.784 54.656l0 274.752L237.696 786.56 237.696 237.696l206.016 0c6.656 0 10.752 0 13.248 0C487.68 237.696 512 213.184 512 182.848 512 152.32 487.36 128 456.96 128L183.04 128C153.216 128 128 152.576 128 182.848c0 3.136 0.256 6.272 0.768 9.28C128.256 195.136 128 198.272 128 201.408l0 639.488c0 0.064 0 0.192 0 0.256 0 0.128 0 0.192 0 0.32 0 30.528 24.512 54.784 54.784 54.784l646.976 0c6.592 0 9.728 0 11.712 0 28.736 0 52.928-22.976 54.464-51.968C896 843.264 896 842.304 896 841.344l0-20.352L896 561.408 896 512.128C896 481.792 871.424 457.152 841.152 457.152z"></path>
</svg>

              </i>
            </a>
          
        
      </li><li class="mobile-menu-item">
        
          
          <div class="mobile-menu-parent">
            <span class="mobile-submenu-open"></span>
            <a href="https://yixy.github.io/youzhilane/post/">
              归档
            </a>
          </div>
          <ul class="mobile-submenu-list">
            
              <li>
                <a href="https://yixy.github.io/youzhilane/post/">日期</a>
              </li>
            
              <li>
                <a href="https://yixy.github.io/youzhilane/tags/">标签</a>
              </li>
            
          </ul>
        
      </li>
    

    
  </ul>
</nav>


  
    






  <link rel="stylesheet" href="/youzhilane/lib/photoswipe/photoswipe.min.css" />
  <link rel="stylesheet" href="/youzhilane/lib/photoswipe/default-skin/default-skin.min.css" />




<div class="pswp" tabindex="-1" role="dialog" aria-hidden="true">

<div class="pswp__bg"></div>

<div class="pswp__scroll-wrap">
    
    <div class="pswp__container">
      <div class="pswp__item"></div>
      <div class="pswp__item"></div>
      <div class="pswp__item"></div>
    </div>
    
    <div class="pswp__ui pswp__ui--hidden">
    <div class="pswp__top-bar">
      
      <div class="pswp__counter"></div>
      <button class="pswp__button pswp__button--close" title="Close (Esc)"></button>
      <button class="pswp__button pswp__button--share" title="Share"></button>
      <button class="pswp__button pswp__button--fs" title="Toggle fullscreen"></button>
      <button class="pswp__button pswp__button--zoom" title="Zoom in/out"></button>
      
      
      <div class="pswp__preloader">
        <div class="pswp__preloader__icn">
          <div class="pswp__preloader__cut">
            <div class="pswp__preloader__donut"></div>
          </div>
        </div>
      </div>
    </div>
    <div class="pswp__share-modal pswp__share-modal--hidden pswp__single-tap">
      <div class="pswp__share-tooltip"></div>
    </div>
    <button class="pswp__button pswp__button--arrow--left" title="Previous (arrow left)">
    </button>
    <button class="pswp__button pswp__button--arrow--right" title="Next (arrow right)">
    </button>
    <div class="pswp__caption">
      <div class="pswp__caption__center"></div>
    </div>
    </div>
    </div>
</div>

  

  

  

  <header id="header" class="header container">
    <div class="logo-wrapper">
  <a href="/youzhilane/" class="logo">
    
      友知弄
    
  </a>
</div>

<nav class="site-navbar">
  <ul id="menu" class="menu">
    
    
        <li class="menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/">主页</a>
          

        

      </li>
    
        <li class="menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/categories/">分类</a>
          

        

      </li>
    
        <li class="menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/booklist/">书单</a>
          

        

      </li>
    
        <li class="menu-item">
        
          
          
            <a class="menu-item-link" href="https://yixy.github.io/youzhilane/about/">关于友知弄</a>
          

        

      </li>
    
        <li class="menu-item">
        
          
          
            <a class="menu-item-link" href="https://github.com/yixy" rel="noopener" target="_blank">
              GitHub
              
              <i class="iconfont">
                <svg class="icon" viewBox="0 0 1024 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="18" height="18">
  <path d="M623.36 272.96 473.216 423.04C467.2 429.056 467.072 438.656 472.896 444.416c0 0-6.72-6.656 1.6 1.6C496.064 467.648 528.64 500.224 528.64 500.224 534.464 506.048 544 505.856 550.016 499.904l150.08-150.144 67.328 66.432c9.024 8.96 27.456 4.544 30.4-8.96 19.968-92.608 46.656-227.52 46.656-227.52 6.848-34.496-16.192-56.704-49.92-49.92 0 0-134.656 26.816-227.328 46.784C560.32 178.048 556.352 182.272 554.752 187.136c-3.2 6.208-3.008 14.208 3.776 20.992L623.36 272.96z"></path>
  <path d="M841.152 457.152c-30.528 0-54.784 24.512-54.784 54.656l0 274.752L237.696 786.56 237.696 237.696l206.016 0c6.656 0 10.752 0 13.248 0C487.68 237.696 512 213.184 512 182.848 512 152.32 487.36 128 456.96 128L183.04 128C153.216 128 128 152.576 128 182.848c0 3.136 0.256 6.272 0.768 9.28C128.256 195.136 128 198.272 128 201.408l0 639.488c0 0.064 0 0.192 0 0.256 0 0.128 0 0.192 0 0.32 0 30.528 24.512 54.784 54.784 54.784l646.976 0c6.592 0 9.728 0 11.712 0 28.736 0 52.928-22.976 54.464-51.968C896 843.264 896 842.304 896 841.344l0-20.352L896 561.408 896 512.128C896 481.792 871.424 457.152 841.152 457.152z"></path>
</svg>

              </i>
            </a>
          

        

      </li>
    
        <li class="menu-item">
        
          
          <a class="menu-item-link menu-parent" href="https://yixy.github.io/youzhilane/post/">归档</a>
          <ul class="submenu">
            
              <li>
                <a href="https://yixy.github.io/youzhilane/post/">日期</a>
              </li>
            
              <li>
                <a href="https://yixy.github.io/youzhilane/tags/">标签</a>
              </li>
            
          </ul>

        

      </li>
    

    
    

    
  </ul>
</nav>

  </header>

  <div id="mobile-panel">
    <main id="main" class="main bg-llight">
      <div class="content-wrapper">
        <div id="content" class="content container">
          <article class="post bg-white">
    
    <header class="post-header">
      <h1 class="post-title"></h1>
      
      <div class="post-meta">
        <time datetime="0001-01-01" class="post-time">
          0001-01-01
        </time>
        
        <span class="more-meta"> 约 67 字 </span>
          <span class="more-meta"> 预计阅读 1 分钟 </span>

        
        

        
        
      </div>
    </header>

    
    
<div class="post-toc" id="post-toc">
  <h2 class="post-toc-title">文章目录</h2>
  <div class="post-toc-content">
    <nav id="TableOfContents">
<ul>
<li><a href="#os笔记-8-内存页面置换算法">OS笔记(8)——内存页面置换算法</a>
<ul>
<li><a href="#1-最优页面算法">1. 最优页面算法</a></li>
<li><a href="#2-最近未使用页面置换算法-not-recently-used">2. 最近未使用页面置换算法（Not Recently Used）</a></li>
<li><a href="#3-先进先出算法-first-in-first-out">3. 先进先出算法（First In First Out）</a></li>
<li><a href="#4-第二次机会页面置换算法-second-chance">4. 第二次机会页面置换算法（second chance）</a></li>
<li><a href="#5-时钟页面置换算法-clock">5. 时钟页面置换算法（clock）</a></li>
<li><a href="#6-最近最少使用页面置换算法-least-recently-used">6. 最近最少使用页面置换算法（Least Recently Used）</a></li>
<li><a href="#7-使用软件模拟lru-nur-和-老化算法">7. 使用软件模拟LRU：NUR 和 老化算法</a></li>
<li><a href="#8-工作集页面置换算法">8. 工作集页面置换算法</a></li>
</ul></li>
</ul>
</nav>
  </div>
</div>

    
    <div class="post-content">
      

<h1 id="os笔记-8-内存页面置换算法">OS笔记(8)——内存页面置换算法</h1>

<p>发生缺页中断时，OS必须在内存中选择一个页面将其换出内存，以便为即将调入的页面腾出空间。如果要换出的页面在内存驻留期间已经被修改过，就必须把它写回磁盘以更新该页面在磁盘上的副本；如果该页面没有被修改过，那么它的磁盘上的副本不需要被回写，直接使用调入的页面覆盖原有页面就行了。</p>

<p>最好的两种算法是老化算法和工作集时钟算法，它们分别基于LRU和工作集，具有良好的页面调度性能，可以有效的实现。</p>

<h2 id="1-最优页面算法">1. 最优页面算法</h2>

<p>该算法是可以给出的最好的页面算法，遗憾的是该算法不可能实现。</p>

<ul>
<li>最优页面算法：假设每个页面都可以用在该页面首次被访问前要执行的指令数作为标记，该算法规定应置换标记最大的页面。</li>
</ul>

<h2 id="2-最近未使用页面置换算法-not-recently-used">2. 最近未使用页面置换算法（Not Recently Used）</h2>

<p>当启动一个进程时，操作系统为其每个页面设置两个状态位R和W（其初始值为0）：页面被访问时设置R位为1，页面被修改时设置W位为1。</p>

<p>注意，R位定期（比如时钟中断）会被清0，以区别最近没有被访问的页面和被访问的页面。</p>

<p>页面根据其R和W值可被分为四类：</p>
<div class="highlight"><div class="chroma">
<table class="lntable"><tr><td class="lntd">
<pre class="chroma"><span class="lnt">1
</span><span class="lnt">2
</span><span class="lnt">3
</span><span class="lnt">4
</span></pre></td>
<td class="lntd">
<pre class="chroma">第0类：R=0，M=0
第1类：R=0，M=1
第2类：R=1，M=0
第4类：R=1，M=1</pre></td></tr></table>
</div>
</div>
<ul>
<li>NRU算法：随机地从类编号最小的非空类中挑选一个页面淘汰之。</li>
</ul>

<p>NRU算法可以看做是LRU算法的一个粗糙的实现。</p>

<h2 id="3-先进先出算法-first-in-first-out">3. 先进先出算法（First In First Out）</h2>

<p>操作系统维护一个队列（通常是链表），存放内存中的页面，每次淘汰队首的页面，将最新进入的页面放到队尾。</p>

<p>因为可能抛弃重要页面，所以该算法一般不会单独使用。</p>

<h2 id="4-第二次机会页面置换算法-second-chance">4. 第二次机会页面置换算法（second chance）</h2>

<p>第二次机会页面置换算法是FIFO算法的升级版。</p>

<ul>
<li>第二次机会算法：对FIFO进行了简单的修改，在淘汰页面时，会判断该页R位是否被设置，若R位没被设置则淘汰该页面，否则将该页面R位清0，并且将其放入队尾，然后重新在队首进行搜索。</li>
</ul>

<h2 id="5-时钟页面置换算法-clock">5. 时钟页面置换算法（clock）</h2>

<p>clock算法是对FIFO和第二次机会算法的一个优化，使用环形链表实现数据结构，避免在链表中移动页面，减少不必要的开销。</p>

<h2 id="6-最近最少使用页面置换算法-least-recently-used">6. 最近最少使用页面置换算法（Least Recently Used）</h2>

<p>对最优页面置换算法的一个很好的近似是基于这样的观察：在前面几条指令中频繁使用的页面很可能在后面的几条指令中被使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内仍然不会被使用。</p>

<ul>
<li>LRU算法：在缺页中断发生时，置换掉未使用时间最长的页面。</li>
</ul>

<p>虽然LRU在理论上是可以实现的，但代价很高。为了完全实现LRU，需要在内存中维护一个所有页面的链表，最近最多使用的页面在表头，最近最少使用的页面在表尾。困难的是在每次访问内存时都必须要更新整个链表。在链表中找到一个页面，删除它，然后把它移动到表头是一个非常费时的操作，即使使用硬件实现也一样费时（假设有这样的硬件）。</p>

<blockquote>
<p>然而，还是有一些使用特殊硬件实现LRU的方法。首先考虑一个最简单的近似方法，这个方法要求硬件有一个64位计数器C，它在每条指令执行完后自动加1，每个页表项必须有一个足够容纳这个计数器值的域。在每次访问内存后，将当前的C值保存到被访问页面的页表项中。一旦发生缺页中断，操作系统就检查所有页表项中计数器的值，找到值最小的一个页面，这个页面就是最近最少使用的页面。（这看起来实际上是一个硬件版本的NUR算法）</p>

<p>现在让我们看一看第二个硬件实现的LRU算法。在一个有n个页框的机器中，LRU硬件可以维持一个初值为0的n×n位的矩阵。当访问到页框k时，硬件首先把k行的位都设置成1，再把k列的位都设置成0。在任何时刻，二进制数值最小的行就是最近最少使用的，第二小的行是下一个最近最少使用的，以此类推。</p>
</blockquote>

<p>前面两种LRU算法虽然在理论上都是可以实现的，但只有非常少的计算机拥有这种硬件。因此，需要一个能用软件实现的解决方案。</p>

<h2 id="7-使用软件模拟lru-nur-和-老化算法">7. 使用软件模拟LRU：NUR 和 老化算法</h2>

<p>只有非常少的计算机支持硬件实现LRU。因此，需要考虑一个能够使用软件实现的解决方案。</p>

<ul>
<li>NFU（Not Frequently Used，最不常用）算法：该算法将每个页面与一个软件计数器相关联，计数器的初值为0。每次时钟中断时，由操作系统扫描内存中所有的页面，将每个页面的R位（它的值是0或1）加到它的计数器上。这个计数器大体上跟踪了各个页面被访问的频繁程度。发生缺页中断时，则置换计数器值最小的页面。NFU的主要问题是它“从来不忘记任何事情”。</li>
<li>老化算法：老化算法对NFU进行了修正。首先，在R位被加进之前先将计数器右移一位；其次，将R位加到计数器最左端的位而不是最右端的位。发生缺页中断时，将置换计数器值最小的页面。</li>
</ul>

<h2 id="8-工作集页面置换算法">8. 工作集页面置换算法</h2>

<p>在进程运行的任何阶段，它都只访问较少的一部分页面。</p>

<ul>
<li>进程工作集：一个进程当前正在使用的页面的集合称为它的工作集（working set）。</li>
</ul>

<p>如果整个工作集都被装入到了内存中，那么进程在运行到下一运行阶段（例如，编译器的下一遍扫描）之前，不会产生很多缺页中断。请注意工作集是随着时间变化的。</p>

<p>工作集实际上就是最近k次内存访问所使用过的页面的集合。作为替代，可以使用几种近似的方法。一种常见的近似方法就是，不是向后找最近k次的内存访问，而是考虑其执行时间。</p>

<ul>
<li>基于工作集的页面置换算法：基本思路就是找出一个不在工作集中的页面（在x时间内被访问过的页面）并淘汰它。</li>
<li>工作集时钟页面置换算法：工作集页面算法的时钟版本，具有更好的性能，并且可以高效的实现。</li>
</ul>

    </div>

    
    
<div class="post-copyright">
  <p class="copyright-item">
    <span class="item-title">文章作者</span>
    <span class="item-content">yixy</span>
  </p>
  <p class="copyright-item">
    <span class="item-title">上次更新</span>
    <span class="item-content">
      0001-01-01
      
    </span>
  </p>
  
  <p class="copyright-item">
    <span class="item-title">许可协议</span>
    <span class="item-content"><a rel="license noopener" href="https://creativecommons.org/licenses/by-nc-nd/4.0/" target="_blank">CC BY-NC-ND 4.0</a></span>
  </p>
</div>


    
    
<div class="post-reward">
  <input type="checkbox" name="reward" id="reward" hidden />
  <label class="reward-button" for="reward">赞赏支持</label>
  <div class="qr-code">
    
    
      <label class="qr-code-image" for="reward">
        <img class="image" src="/youzhilane/img/about/wechat.jpg">
        <span>微信打赏</span>
      </label>
    
  </div>
</div>

    <footer class="post-footer">
      

      
      <nav class="post-nav">
        
          <a class="prev" href="/youzhilane/post/01%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/os%E7%AC%94%E8%AE%B07%E5%86%85%E5%AD%98%E5%8A%A8%E6%80%81%E5%88%86%E9%85%8D%E7%AE%97%E6%B3%95/">
            
            <i class="iconfont">
              <svg  class="icon" viewBox="0 0 1024 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="18" height="18">
  <path d="M691.908486 949.511495l75.369571-89.491197c10.963703-12.998035 10.285251-32.864502-1.499144-44.378743L479.499795 515.267417 757.434875 204.940602c11.338233-12.190647 11.035334-32.285311-0.638543-44.850487l-80.46666-86.564541c-11.680017-12.583596-30.356378-12.893658-41.662889-0.716314L257.233596 494.235404c-11.332093 12.183484-11.041474 32.266891 0.657986 44.844348l80.46666 86.564541c1.772366 1.910513 3.706415 3.533476 5.750981 4.877077l306.620399 321.703933C662.505829 963.726242 680.945807 962.528973 691.908486 949.511495z"></path>
</svg>

            </i>
            <span class="prev-text nav-default"></span>
            <span class="prev-text nav-mobile">上一篇</span>
          </a>
        
          <a class="next" href="/youzhilane/post/01%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/os%E7%AC%94%E8%AE%B09%E6%96%87%E4%BB%B6%E7%B3%BB%E7%BB%9F/">
            <span class="next-text nav-default"></span>
            <span class="prev-text nav-mobile">下一篇</span>
            
            <i class="iconfont">
              <svg class="icon" viewBox="0 0 1024 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="18" height="18">
  <path d="M332.091514 74.487481l-75.369571 89.491197c-10.963703 12.998035-10.285251 32.864502 1.499144 44.378743l286.278095 300.375162L266.565125 819.058374c-11.338233 12.190647-11.035334 32.285311 0.638543 44.850487l80.46666 86.564541c11.680017 12.583596 30.356378 12.893658 41.662889 0.716314l377.434212-421.426145c11.332093-12.183484 11.041474-32.266891-0.657986-44.844348l-80.46666-86.564541c-1.772366-1.910513-3.706415-3.533476-5.750981-4.877077L373.270379 71.774697C361.493148 60.273758 343.054193 61.470003 332.091514 74.487481z"></path>
</svg>

            </i>
          </a>
      </nav>
    </footer>
  </article>

  
  
  
  

  
  

  

  
  

  

  

  

    

  

        </div>
      </div>
    </main>

    <footer id="footer" class="footer">
      <div class="icon-links">
  
  
    <a href="mailto:youzhilane01@gmail.com" rel="me noopener" class="iconfont"
      title="email" >
      <svg class="icon" viewBox="0 0 1451 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="36" height="36">
  <path d="M664.781909 681.472759 0 97.881301C0 3.997201 71.046997 0 71.046997 0L474.477909 0 961.649408 0 1361.641813 0C1361.641813 0 1432.688811 3.997201 1432.688811 97.881301L771.345323 681.472759C771.345323 681.472759 764.482731 685.154773 753.594283 688.65053L753.594283 688.664858C741.602731 693.493018 729.424896 695.068979 718.077952 694.839748 706.731093 695.068979 694.553173 693.493018 682.561621 688.664858L682.561621 688.65053C671.644501 685.140446 664.781909 681.472759 664.781909 681.472759L664.781909 681.472759ZM718.063616 811.603883C693.779541 811.016482 658.879232 802.205449 619.10784 767.734955 542.989056 701.759633 0 212.052267 0 212.052267L0 942.809523C0 942.809523 0 1024 83.726336 1024L682.532949 1024 753.579947 1024 1348.948139 1024C1432.688811 1024 1432.688811 942.809523 1432.688811 942.809523L1432.688811 212.052267C1432.688811 212.052267 893.138176 701.759633 817.019477 767.734955 777.248 802.205449 742.347691 811.03081 718.063616 811.603883L718.063616 811.603883Z"></path>
</svg>

    </a>


<a href="https://yixy.github.io/youzhilane/index.xml" rel="noopener alternate" type="application/rss&#43;xml"
    class="iconfont" title="rss" target="_blank">
    <svg class="icon" viewBox="0 0 1024 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="30" height="30">
  <path d="M819.157333 1024C819.157333 574.592 449.408 204.8 0 204.8V0c561.706667 0 1024 462.293333 1024 1024h-204.842667zM140.416 743.04a140.8 140.8 0 0 1 140.501333 140.586667A140.928 140.928 0 0 1 140.074667 1024C62.72 1024 0 961.109333 0 883.626667s62.933333-140.544 140.416-140.586667zM678.784 1024h-199.04c0-263.210667-216.533333-479.786667-479.744-479.786667V345.173333c372.352 0 678.784 306.517333 678.784 678.826667z"></path>
</svg>

  </a>
   
</div>

<div class="copyright">
  <span class="power-by">
    Powered by <a class="hexo-link" href="https://gohugo.io">Hugo</a>
  </span>
  <span class="division">|</span>
  <span class="theme-info">
    Theme - <a class="theme-link" href="https://github.com/xianmin/hugo-theme-jane">Jane</a>
  </span>

  <span class="copyright-year">
    &copy;
    2019
    <span class="heart">
      
      <i class="iconfont">
        <svg class="icon" viewBox="0 0 1025 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="14" height="14">
  <path d="M1000.1 247.9c-15.5-37.3-37.6-70.6-65.7-98.9-54.4-54.8-125.8-85-201-85-85.7 0-166 39-221.4 107.4C456.6 103 376.3 64 290.6 64c-75.1 0-146.5 30.4-201.1 85.6-28.2 28.5-50.4 61.9-65.8 99.3-16 38.8-24 79.9-23.6 122.2 0.7 91.7 40.1 177.2 108.1 234.8 3.1 2.6 6 5.1 8.9 7.8 14.9 13.4 58 52.8 112.6 102.7 93.5 85.5 209.9 191.9 257.5 234.2 7 6.1 15.8 9.5 24.9 9.5 9.2 0 18.1-3.4 24.9-9.5 34.5-30.7 105.8-95.9 181.4-165 74.2-67.8 150.9-138 195.8-178.2 69.5-57.9 109.6-144.4 109.9-237.3 0.1-42.5-8-83.6-24-122.2z"
   fill="#8a8a8a"></path>
</svg>

      </i>
    </span><span class="author">
        yixy
        
      </span></span>

  
  

  
</div>

    </footer>

    <div class="back-to-top" id="back-to-top">
      <i class="iconfont">
        
        <svg class="icon" viewBox="0 0 1024 1024" version="1.1"
  xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
  width="35" height="35">
  <path d="M510.866688 227.694839 95.449397 629.218702l235.761562 0-2.057869 328.796468 362.40389 0L691.55698 628.188232l241.942331-3.089361L510.866688 227.694839zM63.840492 63.962777l894.052392 0 0 131.813095L63.840492 195.775872 63.840492 63.962777 63.840492 63.962777zM63.840492 63.962777"></path>
</svg>

      </i>
    </div>
  </div>
  
<script type="text/javascript" src="/youzhilane/lib/jquery/jquery-3.2.1.min.js"></script>
  <script type="text/javascript" src="/youzhilane/lib/slideout/slideout-1.0.1.min.js"></script>




<script type="text/javascript" src="/youzhilane/js/main.638251f4230630f0335d8c6748e53a96f94b72670920b60c09a56fdc8bece214.js" integrity="sha256-Y4JR9CMGMPAzXYxnSOU6lvlLcmcJILYMCaVv3Ivs4hQ=" crossorigin="anonymous"></script>












  
    <script type="text/javascript" src="/youzhilane/js/load-photoswipe.js"></script>
    <script type="text/javascript" src="/youzhilane/lib/photoswipe/photoswipe.min.js"></script>
    <script type="text/javascript" src="/youzhilane/lib/photoswipe/photoswipe-ui-default.min.js"></script>
  















</body>
</html>
